Flaski testimine: rakenduse testimise strateegiad

Testimine on tarkvaraarenduse nurgakivi ja eriti oluline selliste raamistikega nagu Flask loodud veebirakenduste jaoks. Testide kirjutamine aitab tagada teie rakenduse õige toimimise, hooldatavuse ja vähendab vigade sissetoomise riski. See põhjalik juhend uurib erinevaid Flaski testimise strateegiaid, pakkudes praktilisi näiteid ja teostatavaid ülevaateid arendajatele kogu maailmas.

Miks testida oma Flaski rakendust?

Testimine pakub arvukalt eeliseid. Kaaluge neid peamisi eeliseid:

• Parandatud koodikvaliteet: Testid julgustavad kirjutama puhtamat, moodulaarsemat ja hooldatavamat koodi.
• Varajane vigade avastamine: Vigade püüdmine arendustsükli alguses säästab aega ja ressursse.
• Suurem enesekindlus: Hästi testitud kood annab teile enesekindlust muudatuste tegemisel või uute funktsioonide lisamisel.
• Hõlbustab refaktoreerimist: Testid toimivad turvavõrguna koodi refaktoreerimisel, tagades, et te pole midagi rikkunud.
• Dokumentatsioon: Testid toimivad elava dokumentatsioonina, illustreerides, kuidas teie koodi on kavas kasutada.
• Toetab pidevat integratsiooni (CI): Automatiseeritud testid on CI-torujuhtmete jaoks hädavajalikud, võimaldades kiireid ja usaldusväärseid juurutusi.

Testimise tüübid Flaskis

Erinevad testitüübid teenivad erinevaid eesmärke. Õige testimise strateegia valimine sõltub teie rakenduse keerukusest ja spetsiifilistest vajadustest. Siin on kõige tavalisemad tüübid:

1. Ühikutestimine

Ühikutestid keskenduvad teie rakenduse väikseimate testitavate üksuste, tavaliselt üksikute funktsioonide või meetodite testimisele. Eesmärk on isoleerida ja kontrollida iga üksuse käitumist iseseisvalt. See on tugeva testimisstrateegia alus.

Näide: Kaaluge Flaski rakendust funktsiooniga kahe arvu summa arvutamiseks:

            # app.py
from flask import Flask

app = Flask(__name__)

def add(x, y):
    return x + y

            

              
                Copy
              
            
          

Ühikutest (pytesti kasutades):

            # test_app.py (samas kataloogis või `tests` kataloogis)
import pytest
from app import add

def test_add():
    assert add(2, 3) == 5
    assert add(-1, 1) == 0
    assert add(0, 0) == 0

            

              
                Copy
              
            
          

Selle testi käitamiseks kasutaksite oma terminalis pytesti: pytest. Pytest avastab ja käitab automaatselt testid failides, mis algavad `test_`. See demonstreerib põhiprintsiipi: testige üksikuid funktsioone või klasse.

2. Integratsioonitestimine

Integratsioonitestid kontrollivad, kas teie rakenduse erinevad moodulid või komponendid töötavad õigesti koos. Need keskenduvad teie koodi erinevate osade vahelisele interaktsioonile, nagu andmebaasi interaktsioonid, API kutsed või erinevate Flaski marsruutide vaheline suhtlus. See valideerib liidesed ja andmevoo.

Näide: Andmebaasiga suhtleva lõpp-punkti testimine (SQLAlchemy abil):

            # app.py
from flask import Flask, jsonify, request
from flask_sqlalchemy import SQLAlchemy

app = Flask(__name__)
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///:memory:' # Testimiseks kasutage mälus SQLite andmebaasi
db = SQLAlchemy(app)

class Task(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    description = db.Column(db.String(200))
    done = db.Column(db.Boolean, default=False)

with app.app_context():
    db.create_all()

@app.route('/tasks', methods=['POST'])
def create_task():
    data = request.get_json()
    task = Task(description=data['description'])
    db.session.add(task)
    db.session.commit()
    return jsonify({'message': 'Task created'}), 201

            

              
                Copy
              
            
          

Integratsioonitest (pytesti ja Flaski testikliendi abil):

            # test_app.py
import pytest
from app import app, db, Task
import json

@pytest.fixture
def client():
    with app.test_client() as client:
        with app.app_context():
            yield client

def test_create_task(client):
    response = client.post('/tasks', data=json.dumps({'description': 'Test task'}), content_type='application/json')
    assert response.status_code == 201
    data = json.loads(response.data.decode('utf-8'))
    assert data['message'] == 'Task created'
    # Kontrollige, kas ülesanne on tegelikult andmebaasi loodud
    with app.app_context():
        task = Task.query.filter_by(description='Test task').first()
        assert task is not None
        assert task.description == 'Test task'

            

              
                Copy
              
            
          

See integratsioonitest kontrollib kogu voogu, alates päringu vastuvõtmisest kuni andmete kirjutamiseni andmebaasi.

3. Lõpp-lõpuni (E2E) testimine

E2E testid simuleerivad kasutaja interaktsiooni teie rakendusega algusest lõpuni. Need kontrollivad kogu süsteemi, sealhulgas esiotsa (kui see on olemas), tagasotsa ja mis tahes kolmanda osapoole teenuseid. E2E testid on väärtuslikud probleemide püüdmiseks, mis võivad ühiku- või integratsioonitestidega kahe silma vahele jääda. Nad kasutavad tööriistu, mis simuleerivad reaalset kasutaja brauserit, mis rakendusega interakteerub.

E2E testimise tööriistad:

• Selenium: Kõige laialdasemalt kasutatav brauseri automatiseerimiseks. Toetab laia valikut brausereid.
• Playwright: Kaasaegne alternatiiv Seleniumile, pakkudes kiiremaid ja usaldusväärsemaid teste.
• Cypress: Loodud spetsiaalselt esiotsa testimiseks, tuntud oma kasutusmugavuse ja silumisvõimaluste poolest.

Näide (kontseptuaalne - kasutades ebapraktilist E2E testimise raamistikku):

            # e2e_tests.py
#  (Märkus: See on kontseptuaalne näide ja nõuab E2E testimise raamistikku)
# Tegelik kood varieerub suuresti olenevalt raamistikust

# Eeldame, et lehel '/login' on sisselogimisvorm.

def test_login_success():
    browser.visit('/login')
    browser.fill('username', 'testuser')
    browser.fill('password', 'password123')
    browser.click('Login')
    browser.assert_url_contains('/dashboard')
    browser.assert_text_present('Welcome, testuser')

# Testi ülesande loomist
def test_create_task_e2e():
    browser.visit('/tasks/new') # Eeldame, et aadressil /tasks/new on uus ülesande vorm
    browser.fill('description', 'E2E Test Task')
    browser.click('Create')
    browser.assert_text_present('Task created successfully')

            

              
                Copy
              
            
          

4. Rakenduste ja asenduste kasutamine (Mocking and Stubbing)

Mocking ja stubbing on olulised tehnikad, mida kasutatakse testitava üksuse isoleerimiseks ja selle sõltuvuste kontrollimiseks. Need tehnikad takistavad väliste teenuste või rakenduse teiste osade sekkumist testidesse.

• Mocking: Asendage sõltuvused koormusobjektidega, mis simuleerivad tõeliste sõltuvuste käitumist. See võimaldab teil kontrollida sõltuvuse sisendit ja väljundit, muutes teie koodi isoleeritult testimise võimalikuks. Koormusobjektid saavad salvestada kutsed, nende argumendid ja isegi tagastada spetsiifilisi väärtusi või käivitada erandeid.
• Stubbing: Pakkuge eelnevalt määratletud vastuseid sõltuvustelt. Kasulik, kui sõltuvuse spetsiifiline käitumine pole oluline, kuid see on vajalik testi täitmiseks.

Näide (andmebaasiühenduse koormus ühikutestil):

            # app.py
from flask import Flask

app = Flask(__name__)

def get_user_data(user_id, db_connection):
    # Teeskle andmete hankimist andmebaasist db_connection abil
    user_data = db_connection.get_user(user_id)
    return user_data

            

              
                Copy
              
            
          

            # test_app.py
import pytest
from unittest.mock import MagicMock
from app import get_user_data

def test_get_user_data_with_mock():
    # Loo koormus andmebaasiühendus
    mock_db_connection = MagicMock()
    mock_db_connection.get_user.return_value = {'id': 1, 'name': 'Test User'}

    # Kutsu funktsiooni koormusega
    user_data = get_user_data(1, mock_db_connection)

    # Kontrollige, et funktsioon tagastas oodatud andmed
    assert user_data == {'id': 1, 'name': 'Test User'}

    # Kontrollige, et koormusobjekti kutsuti õigesti
    mock_db_connection.get_user.assert_called_once_with(1)

            

              
                Copy
              
            
          

Testimise raamistikud ja raamatukogud

Mitu raamistikku ja raamatukogu võivad Flaski testimist lihtsustada.

• pytest: Populaarne ja mitmekülgne testimise raamistik, mis lihtsustab testide kirjutamist ja täitmist. Pakub rikkalikke funktsioone, nagu näiteks fixture'id, testide avastamine ja aruandlus.
• unittest (Pythoni sisseehitatud testimise raamistik): Pythoni põhiline moodul. Kuigi funktsionaalne, on see üldiselt vähem kompaktne ja funktsioonirikas võrreldes pytestiga.
• Flaski testiklient: Pakub mugavat viisi teie Flaski marsruutide ja rakenduskontekstiga interaktsioonide testimiseks. (Vt integratsioonitesti näidet ülal.)
• Flask-Testing: Laiendus, mis lisab Flaskile testimisega seotud utiliite, kuid mida tänapäeval vähem kasutatakse, kuna pytest on paindlikum.
• Mock (unittest.mock-ist): Kasutatakse sõltuvuste koormuseks (vt näiteid ülal).

Parimad praktikad Flaski testimiseks

• Kirjutage testid varakult: Kasutage testipõhise arenduse (TDD) printsiipe. Kirjutage oma testid enne, kui kirjutate oma koodi. See aitab määratleda nõudeid ja tagada, et teie kood vastab nendele nõuetele.
• Hoidke testid fookustatud: Igal testil peaks olema üks, selgelt määratletud eesmärk.
• Testige servajuhtumeid: Ärge testige ainult õnnelikku teed; testige piiritingimusi, veatingimusi ja kehtetuid sisendeid.
• Tehke testid sõltumatuks: Testid ei tohiks sõltuda täitmise järjekorrast ega jagada olekut. Kasutage testandmete seadistamiseks ja utiliseerimiseks fixture'eid.
• Kasutage tähendusrikkaid testinimed: Testinimed peaksid selgelt näitama, mida testitakse ja mida oodatakse.
• Püüdke saavutada kõrget testikatet: Püüdke katta oma koodi nii palju kui võimalik testidega. Testikatte aruanded (genereeritud tööriistadega nagu `pytest-cov`) aitavad teil tuvastada testimata osi teie koodibaasist.
• Automatiseerige oma testid: Integreerige testid oma CI/CD torujuhtmesse, et neid automaatselt käivitada iga kord, kui koodi muudatusi tehakse.
• Testige isoleeritult: Kasutage testitavate üksuste isoleerimiseks koormusi ja asendusi.

Testipõhine arendus (TDD)

TDD on arendusmetodoloogia, kus te kirjutate testid *enne* tegeliku koodi kirjutamist. See protsess järgib tavaliselt järgmisi samme:

1. Kirjutage läbikukkunud test: Määratlege funktsioon, mida soovite rakendada, ja kirjutage test, mis läheb läbi, kuna funktsioon veel puudub.
2. Kirjutage kood testi läbimiseks: Kirjutage minimaalne vajalik kood, et test läbi läheks.
3. Refaktoreerige: Kui test on läbi läinud, refaktoreerige oma kood selle disaini ja hooldatavuse parandamiseks, tagades, et testid jätkuvad läbimisega.
4. Korda: Itereerige seda tsüklit iga funktsiooni või funktsionaalsuse osa kohta.

TDD võib viia puhtama, paremini testitava koodini ja aitab tagada, et teie rakendus vastab selle nõuetele. Seda iteratiivset lähenemist kasutavad laialdaselt tarkvaraarendusmeeskonnad kogu maailmas.

Testikate ja koodikvaliteet

Testikate mõõdab teie koodi protsenti, mida teie testid täidavad. Kõrge testikate näitab üldiselt suuremat usaldust teie koodi töökindluse suhtes. Tööriistad nagu `pytest-cov` (pytesti plugin) aitavad teil luua kattearuandeid. Need aruanded tõstavad esile koodiread, mida ei testita. Kõrge testikatte poole püüdlemine julgustab arendajaid põhjalikumalt testima.

Testide silumine

Testide silumine võib olla sama oluline kui teie rakenduse koodi silumine. Silumisel aitavad mitmed tehnikad:

• Prindilaused: Kasutage `print()` lauseid muutujate väärtuste kontrollimiseks ja täitmise voo jälgimiseks testides.
• Silurid: Kasutage silurit (nt Pythonis `pdb`), et testida rida-realt, kontrollida muutujad ja mõista, mis täitmise ajal toimub. PyCharm, VS Code ja teised IDE-d on sisseehitatud silurid.
• Testide isoleerimine: Keskenduge ühele konkreetsele testile korraga probleemide isoleerimiseks ja tuvastamiseks. Kasutage pytesti `-k` lippu testide nimede või nende osade järgi käitamiseks (nt `pytest -k test_create_task`).
• Kasutage `pytest --pdb`: See käivitab testi ja siseneb automaatselt silurisse, kui test ebaõnnestub.
• Logimine: Kasutage logimislauseid, et salvestada teavet testi täitmise kohta, mis võib silumisel abiks olla.

Pidev integratsioon (CI) ja testimine

Pidev integratsioon (CI) on tarkvaraarenduse praktika, kus koodimuudatusi integreeritakse sageli jagatud hoidlasse. CI-süsteemid automatiseerivad ehitamise, testimise ja juurutamise protsessi. Oma testide integreerimine teie CI-torujuhtmega on hädavajalik koodikvaliteedi säilitamiseks ja selle tagamiseks, et uued muudatused ei tooks vigu. Siin on, kuidas see töötab:

1. Koodimuudatused: Arendajad salvestavad koodimuudatused versioonihaldussüsteemi (nt Git).
2. CI-süsteemi käivitus: CI-süsteem (nt Jenkins, GitLab CI, GitHub Actions, CircleCI) käivitatakse nende muudatuste abil (nt push mõne haru külge või pull-taotlus).
3. Ehitis: CI-süsteem ehitab rakenduse. See hõlmab tavaliselt sõltuvuste installimist.
4. Testimine: CI-süsteem käitab teie teste (ühikutestid, integratsioonitestid ja potentsiaalselt E2E-testid).
5. Aruandlus: CI-süsteem genereerib testiaruanded, mis näitavad testide tulemusi (nt edukalt läbinud, ebaõnnestunud, vahele jäetud).
6. Juurutamine (valikuline): Kui kõik testid on läbinud, saab CI-süsteem rakenduse automaatselt lavastamis- või tootmiskeskkonda juurutada.

Automatiseerides testimisprotsessi, aitab CI arendajatel varakult vigu püüda, vähendab juurutamisvigu ja parandab nende koodi üldist kvaliteeti. See aitab kaasa ka kiiretele ja usaldusväärsetele tarkvaraversioonidele.

Näide CI konfiguratsioonist (kontseptuaalne - kasutades GitHub Actions)

See on lihtne näide ja varieerub suuresti olenevalt CI-süsteemist ja projekti seadistusest.

            # .github/workflows/python-app.yml
name: Python Application CI

on:
  push:
    branches: [ "main" ]
  pull_request:
    branches: [ "main" ]

jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      - name: Set up Python 3.x
        uses: actions/setup-python@v4
        with:
          python-version: "3.x"
      - name: Install dependencies
        run: |
          python -m pip install --upgrade pip
          pip install -r requirements.txt # Või requirements-dev.txt jne.
      - name: Run tests
        run: pytest
      - name: Coverage report
        run: |
          pip install pytest-cov
          pytest --cov=.

            

              
                Copy
              
            
          

See töövoog teeb järgmist:

• Teie koodi kontrollib välja.
• Pythoni seadistab.
• Teie projekti sõltuvused installib `requirements.txt` (või sarnane).
• Teie testide käitamiseks käitab pytesti.
• Kattearuande genereerib.

Täiustatud testimise strateegiad

Lisaks põhilistele testimistüüpidele on ka täiustatud strateegiaid, mida kaaluda, eriti suurte ja keerukate rakenduste puhul.

• Omaduspõhine testimine: See tehnika hõlmab teie koodi jaoks kehtivate omaduste määratlemist ja nende omaduste testimiseks juhuslike sisendite genereerimist. Raamatukogud nagu Hypothesis Pythoni jaoks.
• Toimivuse testimine: Mõõtke oma rakenduse jõudlust erinevate töökoormuste korral. Tööriistad nagu Locust või JMeter.
• Turvatestimine: Tuvastage turvaauke oma rakenduses. Tööriistad nagu OWASP ZAP.
• Lepingute testimine: Tagab, et teie rakenduse erinevad komponendid (nt mikroteenused) peavad kinni eelnevalt määratletud lepingutest. Pacts on selleks tööriista näide.

Järeldus

Testimine on tarkvaraarenduse elutsükli oluline osa. Põhjaliku testimisstrateegia kasutuselevõtmisega saate oluliselt parandada oma Flaski rakenduste kvaliteeti, töökindlust ja hooldatavust. See hõlmab ühikutestide, integratsioonitestide ja vajadusel ka lõpp-lõpuni testide kirjutamist. Tööriistade nagu pytest kasutamine, tehnikate nagu koormuse kasutamine ja CI/CD torujuhtmete integreerimine on kõik hädavajalikud sammud. Testimisse investeerides saavad arendajad kogu maailmas tarnida töökindlamaid ja usaldusväärsemaid veebirakendusi, mis lõppkokkuvõttes kasu toob globaalsetele kasutajatele.